#include "Headers\Head.h"
#include "wektor.cpp"

wektor<Object*> Object::obiekty;

Object::Object(string nazwa,int kx, int ky) : pos(kx,ky), min(2000,2000),max(0,0),sr_ciezkosci(0,0),licznik(0)
{
    string sciezka ("Graphic\\");
    sciezka +=nazwa;
    sciezka += ".png";
    obiekt_img.LoadFromFile(sciezka);
    obiekt_img.SetSmooth(false);
    shape = obiekt_img;
    obiekt_spr.SetImage(obiekt_img);
    obiekt_spr.SetPosition(pos.x,pos.y);
    wypelnienie(znajdz(Color::White),Color::White, Color::Cyan);
    obramowanie(znajdz(Color::Black),Color::Black,Color::Cyan);
    obiekt_img.CreateMaskFromColor(obiekt_img.GetPixel(0, 0));//tworzy maske przezroczystosci z 1szego piksela
    oblicz_srodkek();
    obiekty.dodaj(this);
    obiekt_img.SaveToFile("Graphic/Maska.png");
    wktr.SetVector(200,0);
}

Object::~Object()
{
    //dtor
}

void Object::wypelnienie(pozycja p, Color szukany, Color zamiennik)
{
    if(obiekt_img.GetPixel(p.x, p.y) == szukany )
    {
        if(!p.x || !p.y)
        throw 'z';
        licznik++;
        sr_ciezkosci.x += p.x;
        sr_ciezkosci.y += p.y;
        p.x<min.x?  min.x = p.x : 0;
        p.x>max.x?  max.x = p.x : 0;
        p.y<min.y?  min.y = p.y : 0;
        p.y>max.y?  max.y = p.y : 0;
        obiekt_img.SetPixel(p.x, p.y, zamiennik);
        wypelnienie(gora(p), szukany, zamiennik);
        wypelnienie(dol(p), szukany, zamiennik);
        wypelnienie(lewo(p), szukany, zamiennik);
        wypelnienie(prawo(p), szukany, zamiennik);
    }
    //cout<<min<<"max: "<<max<<endl;
}

void Object::obramowanie(pozycja p, Color szukany, Color zamiennik)
{
    if(obiekt_img.GetPixel(p.x, p.y) == szukany )
    {
        ramka.push_back(p);
        licznik++;
        sr_ciezkosci.x += p.x;
        sr_ciezkosci.y += p.y;
        p.x<min.x?  min.x = p.x : 0;
        p.x>max.x?  max.x = p.x : 0;
        p.y<min.y?  min.y = p.y : 0;
        p.y>max.y?  max.y = p.y : 0;
        obiekt_img.SetPixel(p.x, p.y, zamiennik);
        obramowanie(gora(p), szukany, zamiennik);
        obramowanie(gora_prawo(p), szukany, zamiennik);
        obramowanie(gora_lewo(p), szukany, zamiennik);
        obramowanie(dol(p), szukany, zamiennik);
        obramowanie(dol_prawo(p), szukany, zamiennik);
        obramowanie(dol_lewo(p), szukany, zamiennik);
        obramowanie(lewo(p), szukany, zamiennik);
        obramowanie(prawo(p), szukany, zamiennik);
    }
    //cout<<min<<"max: "<<max<<endl;
}

pozycja Object::znajdz(Color szukany)
{
    pozycja pixel;
    for (pixel.x = 0; pixel.x < obiekt_img.GetWidth(); pixel.x++)
        for (pixel.y = 0; pixel.y < obiekt_img.GetHeight(); pixel.y++)
            if(obiekt_img.GetPixel(pixel.x,pixel.y) == szukany)
                return pixel;

    throw 1;
}

bool Object::kolizja()
{
    for(unsigned int i = 0; i<obiekty.rozmiar; i++)
    {
        if(obiekty.wsk[i] != this)
        {
            if(odleglosc(obiekty.wsk[i]) < (obiekty.wsk[i]->promien + promien))
                if (sprawdz_piksele(obiekty.wsk[i]))
                    return 1;
        }
    }
    return 0;
}

void Object::oblicz_srodkek()
{
    srodek_spr.x = (max.x + min.x) / 2;// liczenie srodka obrazka
    srodek_spr.y = (max.y + min.y) / 2;
    sr_ciezkosci.x /= licznik;//liczenie srodka ciezkosci na podstawie pikseli
    sr_ciezkosci.y /= licznik;
    cout<<"sr_ciezkosci "<<sr_ciezkosci.x<<" : "<<sr_ciezkosci.y<<endl
        <<"srodek obrazka "<<srodek_spr.x<<" : "<<srodek_spr.y<<endl;
    promien = sqrt(pow((max.x - srodek_spr.x),2) + pow((max.y - srodek_spr.y),2));
    cout<<"promien: "<<promien<<endl<<endl;
    obiekt_spr.SetCenter(sr_ciezkosci.x,sr_ciezkosci.y);
}

inline double Object::odleglosc(Object * wsk)
{
    return sqrt( pow( ( wsk->pos.x - pos.x ), 2 ) + pow( wsk->pos.y - pos.y, 2) );
}

//bool Object::sprawdz_piksele(Object * wsk)
//{
//    pozycja k;
//    for (unsigned int x = 0; x < obiekt_img.GetWidth(); x++)
//        for (unsigned int y = 0; y < obiekt_img.GetHeight(); y++)
//        {
//            //cout<<x<<" "<<y<<endl;
//            k = (wsk->obiekt_spr).TransformToLocal(obiekt_spr.TransformToGlobal(Vector2f(x,y))); // kurwa magiczne przeksztalcenie ;d
//            if(k.x>=0 && k.y>=0 && (k.x <(wsk->obiekt_img).GetWidth() )&&( k.y <(wsk->obiekt_img).GetHeight()))
//                if((obiekt_img.GetPixel(x,y) == Color::Cyan) && wsk->obiekt_img.GetPixel(int(k.x),int(k.y)) == Color::Cyan)
//                    return 1;
//        }
//    return 0;
//}

bool Object::sprawdz_piksele(Object * wsk)
{
    pozycja k;

        for (unsigned int i = 0; i < ramka.size(); i++)
        {
            //cout<<x<<" "<<y<<endl;
            k = (wsk->obiekt_spr).TransformToLocal(obiekt_spr.TransformToGlobal(Vector2f(ramka[i].x,ramka[i].y))); // kurwa magiczne przeksztalcenie ;d
            if(k.x>=0 && k.y>=0 && (k.x <(wsk->obiekt_img).GetWidth() )&&( k.y <(wsk->obiekt_img).GetHeight()))
                if((obiekt_img.GetPixel(ramka[i].x,ramka[i].y) == Color::Cyan) && wsk->obiekt_img.GetPixel(int(k.x),int(k.y)) == Color::Cyan)
                    return 1;
        }
    return 0;
}

void Object::ruch(RenderWindow & okno)
{
//    static double obrot = 0;
// wktr.move(pos);

    const sf::Input & wejscie = okno.GetInput();
        if(wejscie.IsKeyDown( sf::Key::A ))
        obrot(0.8);

        if(wejscie.IsKeyDown( sf::Key::D ))
        obrot(-0.8);
        if(wejscie.IsKeyDown( sf::Key::W ))
        wktr.move(pos);

        if(wejscie.IsKeyDown( sf::Key::S ))
        {
            wktr.value*=-1;
        wktr.move(pos);
        wktr.value*=-1;
        }



    cout<<kolizja()<<"\r";
}
void Object::obrot(double i)
{
    wktr.angle += i;
    if(wktr.angle >= 360)
        wktr.angle = int(wktr.angle) % 360;
    obiekt_spr.SetRotation(wktr.angle);
}
void Object::laduje_teksture(string nazwa)
{
    string sciezka ("Graphic\\");
    sciezka +=nazwa;
    sciezka += ".png";
    tekstura.LoadFromFile(sciezka);
    tekstura.CreateMaskFromColor(tekstura.GetPixel(0, 0));
    tekstura.SetSmooth(true);
    }
